package com.ml.framework.core.dao;

import java.io.Serializable;
import java.sql.SQLException;
import java.util.Collection;
import java.util.List;

import org.hibernate.HibernateException;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.transform.Transformers;
import org.springframework.orm.hibernate3.HibernateCallback;
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;

/**
 * 通用的Hibernate数据操作类，建议使用hibernate进行简单表数据对象的增、删、改、查操作
 */
public class CommonHibernateDao extends HibernateDaoSupport
{

	/**
	 * 根据主键查询一个单独的对象
	 * 
	 
	 * @param clasz
	 * @param pk
	 * @return
	 */
	public <T, PK extends Serializable> T get(Class<T> clasz, PK pk)
	{
		return (T) this.getHibernateTemplate().get(clasz, pk);
	}

	public Session getHibernateSession()
	{
		return getSession();
	}

	/**
	 * 加载所有的对象数据
	 * 
	 
	 * @param clasz
	 * @return
	 */
	public <T> List<T> load(Class<T> clasz)
	{
		return null;// this.getHibernateTemplate().loadAll(clasz);
	}

	/**
	 * 保存一个对象
	 * 
	 
	 * @param entity
	 */
	public <T> void save(T entity)
	{
		this.getHibernateTemplate().save(entity);
	}

	/**
	 * 更新一个对象，必须有主键
	 * 
	 
	 * @param entity
	 */
	public <T> void update(T entity)
	{
		this.getHibernateTemplate().update(entity);
	}

	public <T> void merge(T entity)
	{
		this.getHibernateTemplate().merge(entity);
	}

	/**
	 * 增加或更新实体
	 * 
	 
	 * @param entity
	 */
	public <T> void saveOrUpdate(T entity)
	{
		this.getHibernateTemplate().saveOrUpdate(entity);
	}

	/**
	 * 增加或更新集合中的全部实体
	 * 
	 
	 * @param entities
	 */
	public <T> void saveOrUpdateAll(Collection<T> entities)
	{
		getHibernateTemplate().saveOrUpdateAll(entities);
	}

	/**
	 * 删除一个对象
	 * 
	 
	 * @param entity
	 */
	public <T> void delete(T entity)
	{
		this.getHibernateTemplate().delete(entity);
	}

	/**
	 * 删除多个对象
	 * 
	 
	 * @param entities
	 */
	public <T> void deleteAll(Collection<T> entities)
	{
		this.getHibernateTemplate().deleteAll(entities);
	}

	/**
	 * 强制立即更新缓冲数据到数据库（否则仅在事务提交时才更新）
	 * 
	 
	 */
	public void flush()
	{
		this.getHibernateTemplate().flush();
	}

	/***************** [HSQL] *******************/

	/**
	 * 使用HSQL语句直接增加、更新、删除实体
	 * 
	 
	 * @param queryString
	 * @return
	 */
	public int bulkUpdate(String queryString)
	{
		return getHibernateTemplate().bulkUpdate(queryString);
	}

	/**
	 * 使用带参数的HSQL语句增加、更新、删除实体
	 * 
	 
	 * @param queryString
	 * @param values
	 * @return
	 */
	public int bulkUpdate(String queryString, Object... values)
	{
		return getHibernateTemplate().bulkUpdate(queryString, values);
	}

	/**
	 * 使用HSQL语句检索数据
	 * 
	 
	 * @param queryString
	 * @return
	 */
	public List<?> find(String queryString)
	{
		return getHibernateTemplate().find(queryString);
	}

	/**
	 * 使用带参数的HSQL语句检索数据
	 * 
	 
	 * @param queryString
	 * @param values
	 * @return
	 */
	public List<?> find(String queryString, Object... values)
	{
		return getHibernateTemplate().find(queryString, values);
	}

	/**
	 * 使用带命名的参数的HSQL语句检索数据
	 * 
	 
	 * @param queryString
	 * @param paramNames
	 * @param values
	 * @return
	 */
	public List<?> findByNamedParam(String queryString, String[] paramNames, Object... values)
	{
		return getHibernateTemplate().findByNamedParam(queryString, paramNames, values);
	}

	/***************** [SQL] *******************/

	/**
	 * 执行原生SQL语句进行(新增、删除、修改)
	 * 
	 
	 * @param queryString
	 * @return
	 */
	public int executeUpdate(final String sql)
	{
		return getHibernateTemplate().execute(new HibernateCallback<Integer>()
		{
			@Override
			public Integer doInHibernate(Session session) throws HibernateException, SQLException
			{
				return session.createSQLQuery(sql).executeUpdate();
			}
		});
	}

	/**
	 * 执行原生SQL语句查询返回一个list
	 * 
	 
	 * @param queryString
	 * @return
	 */
	public <T> List<T> executeQueryList(final String sql, final Class<T> clasz)
	{
		return getHibernateTemplate().execute(new HibernateCallback<List<T>>()
		{
			@SuppressWarnings("unchecked")
			@Override
			public List<T> doInHibernate(Session session) throws HibernateException, SQLException
			{
				Query query = session.createSQLQuery(sql).setResultTransformer(Transformers.aliasToBean(clasz));
				return query.list();
			}
		});
	}

	/**
	 * 执行原生SQL语句查询返回一个对象
	 * 
	 * @param queryString
	 * @return
	 */
	public <T> T executeQueryObject(final String sql, final Class<T> clasz)
	{
		return getHibernateTemplate().execute(new HibernateCallback<T>()
		{
			@SuppressWarnings("unchecked")
			@Override
			public T doInHibernate(Session session) throws HibernateException, SQLException
			{
				Query query = session.createSQLQuery(sql).setResultTransformer(Transformers.aliasToBean(clasz));
				return (T) query.uniqueResult();
			}
		});
	}
}
